home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / var / lib / python-support / python2.6 / glchess / gtkui / dialogs.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-04-20  |  22.9 KB  |  712 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. __author__ = 'Robert Ancell <bob27@users.sourceforge.net>'
  5. __license__ = 'GNU General Public License Version 2'
  6. __copyright__ = 'Copyright 2005-2006  Robert Ancell'
  7. import os
  8. from gettext import gettext as _
  9. import gobject
  10. import gtk
  11. import gtk.glade as gtk
  12. import gtk.gdk as gtk
  13. import gtkui
  14. import glchess.ui as glchess
  15.  
  16. class GtkServerList:
  17.     __gui = None
  18.     
  19.     def __init__(self, gui):
  20.         self._GtkServerList__gui = gui
  21.         self._GtkServerList__servers = []
  22.         view = gui.get_widget('server_list')
  23.         if view is not None:
  24.             store = gtk.ListStore(str, gobject.TYPE_PYOBJECT)
  25.             view.set_model(store)
  26.             cell = gtk.CellRendererText()
  27.             column = gtk.TreeViewColumn('name', cell)
  28.             column.add_attribute(cell, 'text', 0)
  29.             view.append_column(column)
  30.         
  31.  
  32.     
  33.     def add(self, name, game):
  34.         '''
  35.         '''
  36.         view = self._GtkServerList__gui.get_widget('server_list')
  37.         if view is None:
  38.             return None
  39.         model = view.get_model()
  40.         iter = model.append()
  41.         model.set(iter, 0, name)
  42.         model.set(iter, 1, game)
  43.  
  44.     
  45.     def getSelected(self):
  46.         '''
  47.         '''
  48.         view = self._GtkServerList__gui.get_widget('server_list')
  49.         if view is None:
  50.             return None
  51.         selection = view.get_selection()
  52.         (model, iter) = selection.get_selected()
  53.         if iter is None:
  54.             return None
  55.         return model.get_value(iter, 1)
  56.  
  57.     
  58.     def remove(self, game):
  59.         '''
  60.         '''
  61.         view = self._GtkServerList__gui.get_widget('server_list')
  62.         if view is None:
  63.             return None
  64.         model = view.get_model()
  65.         iter = model.get_iter_first()
  66.         while iter is not None:
  67.             if model.get_value(iter, 1) is game:
  68.                 break
  69.             
  70.             iter = model.iter_next(iter)
  71.         if iter is not None:
  72.             model.remove(iter)
  73.         
  74.  
  75.  
  76.  
  77. class GtkNewGameDialog:
  78.     '''
  79.     '''
  80.     
  81.     def __init__(self, mainUI, aiModel, game = None):
  82.         """Constructor for a new game dialog.
  83.         
  84.         'mainUI' is the main UI.
  85.         'aiModel' is the AI models to use.
  86.         'game' is the game properties to use (ui.Game).
  87.         """
  88.         self._GtkNewGameDialog__mainUI = mainUI
  89.         self.game = game
  90.         self._GtkNewGameDialog__checking = True
  91.         self._GtkNewGameDialog__customName = False
  92.         self._GtkNewGameDialog__gui = gtkui.loadGladeFile('new_game.glade', 'new_game_dialog')
  93.         self._GtkNewGameDialog__gui.signal_autoconnect(self)
  94.         self.window = self._GtkNewGameDialog__gui.get_widget('new_game_dialog')
  95.         self.window.set_transient_for(mainUI.mainWindow)
  96.         mainUI.setTooltipStyle(self._GtkNewGameDialog__gui.get_widget('info_box'))
  97.         group = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)
  98.         i = 1
  99.         while True:
  100.             widget = self._GtkNewGameDialog__gui.get_widget('label%i' % i)
  101.             if widget is None:
  102.                 break
  103.             
  104.             group.add_widget(widget)
  105.             i += 1
  106.         group = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)
  107.         i = 1
  108.         while True:
  109.             widget = self._GtkNewGameDialog__gui.get_widget('image%i' % i)
  110.             if widget is None:
  111.                 break
  112.             
  113.             group.add_widget(widget)
  114.             i += 1
  115.         defaultTime = glchess.config.get('new_game_dialog/move_time')
  116.         times = [
  117.             (_('Unlimited'), 0),
  118.             (_('One minute'), 60),
  119.             (_('Five minutes'), 300),
  120.             (_('30 minutes'), 1800),
  121.             (_('One hour'), 3600),
  122.             (_('Custom'), -1)]
  123.         timeModel = gtk.ListStore(str, int)
  124.         activeIter = None
  125.         for name, time in times:
  126.             iter = timeModel.append()
  127.             if time == defaultTime:
  128.                 activeIter = iter
  129.             
  130.             timeModel.set(iter, 0, name, 1, time)
  131.         
  132.         widget = self._GtkNewGameDialog__gui.get_widget('time_combo')
  133.         widget.set_model(timeModel)
  134.         if activeIter is None:
  135.             widget.set_active_iter(iter)
  136.         else:
  137.             widget.set_active_iter(activeIter)
  138.         cell = gtk.CellRendererText()
  139.         widget.pack_start(cell, False)
  140.         widget.add_attribute(cell, 'text', 0)
  141.         model = gtk.ListStore(str, int)
  142.         units = [
  143.             (_('seconds'), 1),
  144.             (_('minutes'), 60),
  145.             (_('hours'), 3600)]
  146.         for name, multiplier in units:
  147.             iter = model.append()
  148.             model.set(iter, 0, name, 1, multiplier)
  149.         
  150.         self._GtkNewGameDialog__gui.get_widget('custom_time_spin').set_value(defaultTime)
  151.         widget = self._GtkNewGameDialog__gui.get_widget('custom_time_units_combo')
  152.         widget.set_model(model)
  153.         cell = gtk.CellRendererText()
  154.         widget.pack_start(cell, False)
  155.         widget.add_attribute(cell, 'text', 0)
  156.         widget.set_active(0)
  157.         levelModel = gtk.ListStore(str, str, str)
  158.         levels = [
  159.             ('easy', _('Easy'), 'weather-few-clouds'),
  160.             ('normal', _('Normal'), 'weather-overcast'),
  161.             ('hard', _('Hard'), 'weather-storm')]
  162.         for key, label, icon in levels:
  163.             iter = levelModel.append()
  164.             levelModel.set(iter, 0, key, 1, icon, 2, label)
  165.         
  166.         for name in [
  167.             'black_difficulty_combo',
  168.             'white_difficulty_combo']:
  169.             widget = self._GtkNewGameDialog__gui.get_widget(name)
  170.             if widget is None:
  171.                 continue
  172.             
  173.             widget.set_model(levelModel)
  174.             cell = gtk.CellRendererPixbuf()
  175.             widget.pack_start(cell, False)
  176.             widget.add_attribute(cell, 'icon-name', 1)
  177.             cell = gtk.CellRendererText()
  178.             widget.pack_start(cell, False)
  179.             widget.add_attribute(cell, 'text', 2)
  180.             widget.set_active(1)
  181.         
  182.         firstAIIndex = min(1, len(aiModel))
  183.         for name, index in [
  184.             ('white_type_combo', 0),
  185.             ('black_type_combo', firstAIIndex)]:
  186.             widget = self._GtkNewGameDialog__gui.get_widget(name)
  187.             if widget is None:
  188.                 continue
  189.             
  190.             widget.set_model(aiModel)
  191.             cell = gtk.CellRendererPixbuf()
  192.             widget.pack_start(cell, False)
  193.             widget.add_attribute(cell, 'icon-name', 1)
  194.             cell = gtk.CellRendererText()
  195.             widget.pack_start(cell, False)
  196.             widget.add_attribute(cell, 'text', 2)
  197.             widget.set_active(index)
  198.         
  199.         
  200.         try:
  201.             whiteType = glchess.config.get('new_game_dialog/white/type')
  202.             whiteLevel = glchess.config.get('new_game_dialog/white/difficulty')
  203.             blackType = glchess.config.get('new_game_dialog/black/type')
  204.             blackLevel = glchess.config.get('new_game_dialog/black/difficulty')
  205.         except glchess.config.Error:
  206.             pass
  207.  
  208.         self._GtkNewGameDialog__setCombo('white_type_combo', whiteType)
  209.         self._GtkNewGameDialog__setCombo('white_difficulty_combo', whiteLevel)
  210.         self._GtkNewGameDialog__setCombo('black_type_combo', blackType)
  211.         self._GtkNewGameDialog__setCombo('black_difficulty_combo', blackLevel)
  212.         errors = []
  213.         g = self.game
  214.         if g is not None:
  215.             self._GtkNewGameDialog__gui.get_widget('game_name_entry').set_text(g.name)
  216.             self._GtkNewGameDialog__customName = True
  217.             noEngineFormat = _('Unable to find %s engine')
  218.             if not self._GtkNewGameDialog__setCombo('white_type_combo', g.white.type):
  219.                 errors.append(noEngineFormat % repr(g.white.type))
  220.             
  221.             self._GtkNewGameDialog__setCombo('white_difficulty_combo', g.white.level)
  222.             if not self._GtkNewGameDialog__setCombo('black_type_combo', g.black.type):
  223.                 errors.append(noEngineFormat % repr(g.black.type))
  224.             
  225.             self._GtkNewGameDialog__setCombo('black_difficulty_combo', g.black.level)
  226.             if g.path is not None:
  227.                 self.window.set_title(_('Configure loaded game (%i moves)') % len(g.moves))
  228.             
  229.         
  230.         if len(errors) > 0:
  231.             self._GtkNewGameDialog__gui.get_widget('info_title_label').set_markup('<big><b>%s</b></big>' % _('Game settings changed'))
  232.             self._GtkNewGameDialog__gui.get_widget('info_description_label').set_markup('<i>%s</i>' % '\n'.join(errors))
  233.             self._GtkNewGameDialog__gui.get_widget('info_box').show()
  234.         
  235.         self.window.present()
  236.         self._GtkNewGameDialog__checking = False
  237.         self._GtkNewGameDialog__testReady()
  238.  
  239.     
  240.     def __setCombo(self, comboName, key):
  241.         '''
  242.         '''
  243.         widget = self._GtkNewGameDialog__gui.get_widget(comboName)
  244.         iter = self._GtkNewGameDialog__getIter(widget.get_model(), key)
  245.         if iter is None:
  246.             return False
  247.         widget.set_active_iter(iter)
  248.         return True
  249.  
  250.     
  251.     def __getIter(self, model, key, default = None):
  252.         '''
  253.         '''
  254.         iter = model.get_iter_first()
  255.         while iter:
  256.             if model.get_value(iter, 0) == key:
  257.                 return iter
  258.             iter = model.iter_next(iter)
  259.             continue
  260.             model.get_value(iter, 0) == key
  261.         return default
  262.  
  263.     
  264.     def __getComboData(self, comboBox, index):
  265.         '''
  266.         '''
  267.         model = comboBox.get_model()
  268.         iter = comboBox.get_active_iter()
  269.         if iter is None:
  270.             return None
  271.         data = model.get(iter, index)
  272.         return data[0]
  273.  
  274.     
  275.     def __testReady(self):
  276.         if self._GtkNewGameDialog__checking:
  277.             return None
  278.         self._GtkNewGameDialog__checking = True
  279.         ready = True
  280.         if self._GtkNewGameDialog__customName:
  281.             name = self._GtkNewGameDialog__gui.get_widget('game_name_entry').get_text()
  282.             if len(name) == 0:
  283.                 self._GtkNewGameDialog__customName = False
  284.                 ready = False
  285.             
  286.         else:
  287.             whiteName = self._GtkNewGameDialog__getComboData(self._GtkNewGameDialog__gui.get_widget('white_type_combo'), 2)
  288.             blackName = self._GtkNewGameDialog__getComboData(self._GtkNewGameDialog__gui.get_widget('black_type_combo'), 2)
  289.             format = _('%(white)s versus %(black)s')
  290.             self._GtkNewGameDialog__gui.get_widget('game_name_entry').set_text(format % {
  291.                 'white': whiteName,
  292.                 'black': blackName })
  293.         whiteType = self._GtkNewGameDialog__getComboData(self._GtkNewGameDialog__gui.get_widget('white_type_combo'), 0)
  294.         blackType = self._GtkNewGameDialog__getComboData(self._GtkNewGameDialog__gui.get_widget('black_type_combo'), 0)
  295.         self._GtkNewGameDialog__gui.get_widget('white_difficulty_combo').set_sensitive(whiteType != '')
  296.         self._GtkNewGameDialog__gui.get_widget('black_difficulty_combo').set_sensitive(blackType != '')
  297.         self._GtkNewGameDialog__gui.get_widget('start_button').set_sensitive(ready)
  298.         self._GtkNewGameDialog__checking = False
  299.  
  300.     
  301.     def __startGame(self):
  302.         game = self.game
  303.         if game is None:
  304.             game = glchess.ui.Game()
  305.         
  306.         game.name = self._GtkNewGameDialog__gui.get_widget('game_name_entry').get_text()
  307.         game.allowSpectators = True
  308.         game.white.type = self._GtkNewGameDialog__getComboData(self._GtkNewGameDialog__gui.get_widget('white_type_combo'), 0)
  309.         if game.white.type == '':
  310.             game.white.name = _('White')
  311.         else:
  312.             game.white.name = self._GtkNewGameDialog__getComboData(self._GtkNewGameDialog__gui.get_widget('white_type_combo'), 2)
  313.         game.white.level = self._GtkNewGameDialog__getComboData(self._GtkNewGameDialog__gui.get_widget('white_difficulty_combo'), 0)
  314.         game.black.type = self._GtkNewGameDialog__getComboData(self._GtkNewGameDialog__gui.get_widget('black_type_combo'), 0)
  315.         if game.black.type == '':
  316.             game.black.name = _('Black')
  317.         else:
  318.             game.black.name = self._GtkNewGameDialog__getComboData(self._GtkNewGameDialog__gui.get_widget('black_type_combo'), 2)
  319.         game.black.level = self._GtkNewGameDialog__getComboData(self._GtkNewGameDialog__gui.get_widget('black_difficulty_combo'), 0)
  320.         game.duration = self._GtkNewGameDialog__getGameDuration()
  321.         glchess.config.set('new_game_dialog/move_time', game.duration)
  322.         glchess.config.set('new_game_dialog/white/type', game.white.type)
  323.         glchess.config.set('new_game_dialog/white/difficulty', game.white.level)
  324.         glchess.config.set('new_game_dialog/black/type', game.black.type)
  325.         glchess.config.set('new_game_dialog/black/difficulty', game.black.level)
  326.         self._GtkNewGameDialog__mainUI.feedback.onGameStart(game)
  327.  
  328.     
  329.     def __getGameDuration(self):
  330.         duration = self._GtkNewGameDialog__getComboData(self._GtkNewGameDialog__gui.get_widget('time_combo'), 1)
  331.         if duration < 0:
  332.             multiplier = self._GtkNewGameDialog__getComboData(self._GtkNewGameDialog__gui.get_widget('custom_time_units_combo'), 1)
  333.             duration = self._GtkNewGameDialog__gui.get_widget('custom_time_spin').get_value_as_int() * multiplier
  334.         
  335.         return duration
  336.  
  337.     
  338.     def _on_game_name_edited(self, widget):
  339.         '''Gtk+ callback'''
  340.         if self._GtkNewGameDialog__checking:
  341.             return None
  342.         self._GtkNewGameDialog__customName = True
  343.         self._GtkNewGameDialog__testReady()
  344.  
  345.     
  346.     def _on_time_changed(self, widget):
  347.         '''Gtk+ callback'''
  348.         time = self._GtkNewGameDialog__getComboData(widget, 1)
  349.         w = self._GtkNewGameDialog__gui.get_widget('custom_time_box')
  350.         if time < 0:
  351.             w.show()
  352.         else:
  353.             w.hide()
  354.  
  355.     
  356.     def _on_properties_changed(self, widget, *data):
  357.         '''Gtk+ callback'''
  358.         self._GtkNewGameDialog__testReady()
  359.  
  360.     
  361.     def _on_response(self, dialog, responseId):
  362.         '''Gtk+ callback'''
  363.         if responseId == gtk.RESPONSE_OK:
  364.             self._GtkNewGameDialog__startGame()
  365.         
  366.         dialog.destroy()
  367.         if self._GtkNewGameDialog__mainUI.newGameDialog is self:
  368.             self._GtkNewGameDialog__mainUI.newGameDialog = None
  369.         
  370.  
  371.  
  372.  
  373. class GtkLoadGameDialog:
  374.     '''
  375.     '''
  376.     
  377.     def __init__(self, mainUI):
  378.         '''
  379.         '''
  380.         self._GtkLoadGameDialog__mainUI = mainUI
  381.         self._GtkLoadGameDialog__gui = gtkui.loadGladeFile('load_game.glade')
  382.         self._GtkLoadGameDialog__gui.signal_autoconnect(self)
  383.         self.window = self._GtkLoadGameDialog__gui.get_widget('game_load_dialog')
  384.         self.window.set_transient_for(mainUI.mainWindow)
  385.         mainUI.setTooltipStyle(self._GtkLoadGameDialog__gui.get_widget('error_box'))
  386.         fileChooser = self._GtkLoadGameDialog__gui.get_widget('filechooserwidget')
  387.         
  388.         try:
  389.             directory = str(glchess.config.get('load_directory'))
  390.         except glchess.config.Error:
  391.             pass
  392.  
  393.         fileChooser.set_current_folder(directory)
  394.         pgnFilter = gtk.FileFilter()
  395.         pgnFilter.set_name(_('PGN files'))
  396.         pgnFilter.add_pattern('*.pgn')
  397.         fileChooser.add_filter(pgnFilter)
  398.         allFilter = gtk.FileFilter()
  399.         allFilter.set_name(_('All files'))
  400.         allFilter.add_pattern('*')
  401.         fileChooser.add_filter(allFilter)
  402.         self.window.present()
  403.  
  404.     
  405.     def _on_file_activated(self, widget):
  406.         '''Gtk+ callback'''
  407.         self._on_response(self.window, gtk.RESPONSE_OK)
  408.  
  409.     
  410.     def _on_response(self, dialog, responseId):
  411.         '''Gtk+ callback'''
  412.         chooser = self._GtkLoadGameDialog__gui.get_widget('filechooserwidget')
  413.         if responseId == gtk.RESPONSE_OK or responseId == gtk.RESPONSE_YES:
  414.             folder = chooser.get_current_folder()
  415.             if folder is not None:
  416.                 glchess.config.set('load_directory', folder)
  417.             
  418.             fileName = self._GtkLoadGameDialog__gui.get_widget('filechooserwidget').get_filename()
  419.             if fileName is None:
  420.                 error = _('Please select a file to load')
  421.             else:
  422.                 error = self._GtkLoadGameDialog__mainUI.feedback.loadGame(fileName, responseId == gtk.RESPONSE_YES)
  423.             if error is not None:
  424.                 self.firstExpose = True
  425.                 self._GtkLoadGameDialog__gui.get_widget('error_box').show()
  426.                 self._GtkLoadGameDialog__gui.get_widget('error_title_label').set_markup('<big><b>%s</b></big>' % _('Unabled to load game'))
  427.                 self._GtkLoadGameDialog__gui.get_widget('error_description_label').set_markup('<i>%s</i>' % error)
  428.                 return None
  429.         
  430.         dialog.destroy()
  431.         if self._GtkLoadGameDialog__mainUI.loadGameDialog is self:
  432.             self._GtkLoadGameDialog__mainUI.loadGameDialog = None
  433.         
  434.  
  435.  
  436.  
  437. class GtkSaveGameDialog:
  438.     '''
  439.     '''
  440.     
  441.     def __init__(self, mainUI, view, path = None):
  442.         '''
  443.         '''
  444.         self._GtkSaveGameDialog__mainUI = mainUI
  445.         self._GtkSaveGameDialog__view = view
  446.         self._GtkSaveGameDialog__gui = gtkui.loadGladeFile('save_game.glade')
  447.         self._GtkSaveGameDialog__gui.signal_autoconnect(self)
  448.         mainUI.setTooltipStyle(self._GtkSaveGameDialog__gui.get_widget('error_box'))
  449.         self.window = self._GtkSaveGameDialog__gui.get_widget('save_dialog')
  450.         self.window.set_transient_for(mainUI.mainWindow)
  451.         chooser = self._GtkSaveGameDialog__gui.get_widget('filechooser')
  452.         
  453.         try:
  454.             directory = str(glchess.config.get('save_directory'))
  455.         except glchess.config.Error:
  456.             pass
  457.  
  458.         chooser.set_current_folder(directory)
  459.         pgnFilter = gtk.FileFilter()
  460.         pgnFilter.set_name('PGN files')
  461.         pgnFilter.add_pattern('*.pgn')
  462.         chooser.add_filter(pgnFilter)
  463.         allFilter = gtk.FileFilter()
  464.         allFilter.set_name('All files')
  465.         allFilter.add_pattern('*')
  466.         chooser.add_filter(allFilter)
  467.         if path is not None:
  468.             chooser.set_current_name(path)
  469.         
  470.  
  471.     
  472.     def _on_file_activated(self, widget):
  473.         '''Gtk+ callback'''
  474.         self._on_response(self.window, gtk.RESPONSE_OK)
  475.  
  476.     
  477.     def __setError(self, title, content):
  478.         '''
  479.         '''
  480.         self.firstExpose = True
  481.         self._GtkSaveGameDialog__gui.get_widget('error_box').show()
  482.         self._GtkSaveGameDialog__gui.get_widget('error_title_label').set_markup('<big><b>%s</b></big>' % title)
  483.         self._GtkSaveGameDialog__gui.get_widget('error_description_label').set_markup('<i>%s</i>' % content)
  484.  
  485.     
  486.     def _on_response(self, dialog, responseId):
  487.         '''Gtk+ callback'''
  488.         chooser = self._GtkSaveGameDialog__gui.get_widget('filechooser')
  489.         if responseId == gtk.RESPONSE_OK:
  490.             fname = chooser.get_filename()
  491.             if fname is None:
  492.                 self._GtkSaveGameDialog__setError(_('Please enter a file name'), '')
  493.                 return None
  494.             if fname[-4:].lower() != '.pgn':
  495.                 fname += '.pgn'
  496.             
  497.             folder = chooser.get_current_folder()
  498.             if folder is not None:
  499.                 glchess.config.set('save_directory', folder)
  500.             
  501.             error = self._GtkSaveGameDialog__mainUI._saveView(self._GtkSaveGameDialog__view, fname)
  502.             if error is not None:
  503.                 self._GtkSaveGameDialog__setError(_('Unabled to save game'), error)
  504.                 return None
  505.         else:
  506.             self._GtkSaveGameDialog__mainUI._saveView(self._GtkSaveGameDialog__view, None)
  507.         dialog.destroy()
  508.  
  509.  
  510.  
  511. class GtkPreferencesDialog:
  512.     '''
  513.     '''
  514.     
  515.     def __init__(self, mainUI):
  516.         """Constructor for the preferences dialog.
  517.         
  518.         'mainUI' is the main UI.
  519.         """
  520.         self._GtkPreferencesDialog__gui = gtkui.loadGladeFile('preferences.glade', 'preferences')
  521.         self._GtkPreferencesDialog__gui.signal_autoconnect(self)
  522.         self._GtkPreferencesDialog__gui.get_widget('preferences').set_transient_for(mainUI.mainWindow)
  523.         moveModel = gtk.ListStore(str, str)
  524.         widget = self._GtkPreferencesDialog__gui.get_widget('move_format_combo')
  525.         widget.set_model(moveModel)
  526.         move_formats = [
  527.             ('human', _('Human')),
  528.             ('san', _('Standard Algebraic')),
  529.             ('fan', _('Figurine')),
  530.             ('lan', _('Long Algebraic'))]
  531.         for key, label in move_formats:
  532.             iter = moveModel.append()
  533.             moveModel.set(iter, 0, label, 1, key)
  534.         
  535.         boardModel = gtk.ListStore(str, str)
  536.         widget = self._GtkPreferencesDialog__gui.get_widget('board_combo')
  537.         widget.set_model(boardModel)
  538.         view_list = [
  539.             ('white', _('White Side')),
  540.             ('black', _('Black Side')),
  541.             ('human', _('Human Side')),
  542.             ('current', _('Current Player'))]
  543.         for key, label in view_list:
  544.             iter = boardModel.append()
  545.             boardModel.set(iter, 0, label, 1, key)
  546.         
  547.         promotionModel = gtk.ListStore(str, str)
  548.         widget = self._GtkPreferencesDialog__gui.get_widget('promotion_type_combo')
  549.         widget.set_model(promotionModel)
  550.         promotion_list = [
  551.             ('queen', _('chess-piece|Queen')),
  552.             ('knight', _('chess-piece|Knight')),
  553.             ('rook', _('chess-piece|Rook')),
  554.             ('bishop', _('chess-piece|Bishop'))]
  555.         for key, label in promotion_list:
  556.             
  557.             try:
  558.                 label = label.split('|', 1)[1]
  559.             except IndexError:
  560.                 pass
  561.  
  562.             iter = promotionModel.append()
  563.             promotionModel.set(iter, 0, label, 1, key)
  564.         
  565.         for key in [
  566.             'show_3d',
  567.             'show_3d_smooth',
  568.             'show_toolbar',
  569.             'show_history',
  570.             'show_move_hints',
  571.             'show_numbering',
  572.             'move_format',
  573.             'board_view',
  574.             'promotion_type']:
  575.             glchess.config.watch(key, self._GtkPreferencesDialog__applyConfig)
  576.             
  577.             try:
  578.                 value = glchess.config.get(key)
  579.             except glchess.config.Error:
  580.                 continue
  581.  
  582.             self._GtkPreferencesDialog__applyConfig(key, value)
  583.         
  584.  
  585.     
  586.     def __applyConfig(self, name, value):
  587.         '''
  588.         '''
  589.         if name == 'show_3d':
  590.             self._GtkPreferencesDialog__gui.get_widget('show_3d').set_active(value)
  591.             self._GtkPreferencesDialog__gui.get_widget('show_3d_smooth').set_sensitive(value)
  592.         elif name == 'show_3d_smooth':
  593.             self._GtkPreferencesDialog__gui.get_widget('show_3d_smooth').set_active(value)
  594.         elif name == 'show_toolbar':
  595.             self._GtkPreferencesDialog__gui.get_widget('show_toolbar').set_active(value)
  596.         elif name == 'show_history':
  597.             self._GtkPreferencesDialog__gui.get_widget('show_history').set_active(value)
  598.         elif name == 'show_move_hints':
  599.             self._GtkPreferencesDialog__gui.get_widget('show_move_hints').set_active(value)
  600.         elif name == 'show_numbering':
  601.             self._GtkPreferencesDialog__gui.get_widget('show_numbering').set_active(value)
  602.         elif name == 'move_format':
  603.             widget = self._GtkPreferencesDialog__gui.get_widget('move_format_combo')
  604.             for row in widget.get_model():
  605.                 if row[1] == value:
  606.                     widget.set_active_iter(row.iter)
  607.                     continue
  608.             
  609.         elif name == 'promotion_type':
  610.             widget = self._GtkPreferencesDialog__gui.get_widget('promotion_type_combo')
  611.             for row in widget.get_model():
  612.                 if row[1] == value:
  613.                     widget.set_active_iter(row.iter)
  614.                     continue
  615.             
  616.         elif name == 'board_view':
  617.             widget = self._GtkPreferencesDialog__gui.get_widget('board_combo')
  618.             for row in widget.get_model():
  619.                 if row[1] == value:
  620.                     widget.set_active_iter(row.iter)
  621.                     continue
  622.             
  623.         elif not False:
  624.             raise AssertionError, 'Unknown config item: %s' % name
  625.  
  626.     
  627.     def setVisible(self, isVisible):
  628.         window = self._GtkPreferencesDialog__gui.get_widget('preferences')
  629.         if isVisible:
  630.             window.present()
  631.         else:
  632.             window.hide()
  633.  
  634.     
  635.     def _on_response(self, dialog, responseId):
  636.         '''Gtk+ callback'''
  637.         self.setVisible(False)
  638.  
  639.     
  640.     def _on_delete(self, dialog, event):
  641.         '''Gtk+ callback'''
  642.         self.setVisible(False)
  643.         return True
  644.  
  645.     
  646.     def _on_move_format_combo_changed(self, widget):
  647.         '''Gtk+ callback'''
  648.         model = widget.get_model()
  649.         iter = widget.get_active_iter()
  650.         if iter is None:
  651.             return None
  652.         data = model.get(iter, 1)
  653.         if data[0] is not None:
  654.             glchess.config.set('move_format', data[0])
  655.         
  656.  
  657.     
  658.     def _on_board_combo_changed(self, widget):
  659.         '''Gtk+ callback'''
  660.         model = widget.get_model()
  661.         iter = widget.get_active_iter()
  662.         if iter is None:
  663.             return None
  664.         data = model.get(iter, 1)
  665.         if data[0] is not None:
  666.             glchess.config.set('board_view', data[0])
  667.         
  668.  
  669.     
  670.     def _on_promotion_type_combo_changed(self, widget):
  671.         '''Gtk+ callback'''
  672.         model = widget.get_model()
  673.         iter = widget.get_active_iter()
  674.         if iter is None:
  675.             return None
  676.         data = model.get(iter, 1)
  677.         if data[0] is not None:
  678.             glchess.config.set('promotion_type', data[0])
  679.         
  680.  
  681.     
  682.     def _on_3d_view_activate(self, widget):
  683.         '''Gtk+ callback'''
  684.         glchess.config.set('show_3d', widget.get_active())
  685.  
  686.     
  687.     def _on_3d_smooth_toggled(self, widget):
  688.         '''Gtk+ callback'''
  689.         glchess.config.set('show_3d_smooth', widget.get_active())
  690.  
  691.     
  692.     def _on_show_toolbar_activate(self, widget):
  693.         '''Gtk+ callback'''
  694.         glchess.config.set('show_toolbar', widget.get_active())
  695.  
  696.     
  697.     def _on_show_history_activate(self, widget):
  698.         '''Gtk+ callback'''
  699.         glchess.config.set('show_history', widget.get_active())
  700.  
  701.     
  702.     def _on_move_hints_activate(self, widget):
  703.         '''Gtk+ callback'''
  704.         glchess.config.set('show_move_hints', widget.get_active())
  705.  
  706.     
  707.     def _on_board_numbering_activate(self, widget):
  708.         '''Gtk+ callback'''
  709.         glchess.config.set('show_numbering', widget.get_active())
  710.  
  711.  
  712.